/*
 * Copyright (C) 2023 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
const LF = "\n"

export interface ParsedResponse {
  readonly messages: string[]
  readonly rest: string
}

/**
 * Parse an FTP control response as a collection of messages. A message is a complete
 * single- or multiline response. A response can also contain multiple multiline responses
 * that will each be represented by a message. A response can also be incomplete
 * and be completed on the next incoming data chunk for which case this function also
 * describes a `rest`. This function converts all CRLF to LF.
 */
export function parseControlResponse(text: string): ParsedResponse {
  const lines = text.split(/\r?\n/).filter(isNotBlank)
  const messages = []
  let startAt = 0
  let tokenRegex: RegExp | undefined
  for (let i = 0; i < lines.length; i++) {
    const line = lines[i]
    // No group has been opened.
    if (!tokenRegex) {
      if (isMultiline(line)) {
        // Open a group by setting an expected token.
        const token = line.substr(0, 3)
        tokenRegex = new RegExp(`^${token}(?:$| )`)
        startAt = i
      }
      else if (isSingleLine(line)) {
        // Single lines can be grouped immediately.
        messages.push(line)
      }
    }
    // Group has been opened, expect closing token.
    else if (tokenRegex.test(line)) {
      tokenRegex = undefined
      messages.push(lines.slice(startAt, i + 1).join(LF))
    }
  }
  // The last group might not have been closed, report it as a rest.
  const rest = tokenRegex ? lines.slice(startAt).join(LF) + LF : ""
  return { messages, rest }
}

export function isSingleLine(line: string) {
  return /^\d\d\d(?:$| )/.test(line)
}

export function isMultiline(line: string) {
  return /^\d\d\d-/.test(line)
}

/**
 * Return true if an FTP return code describes a positive completion.
 */
export function positiveCompletion(code: number): boolean {
  return code >= 200 && code < 300
}

/**
 * Return true if an FTP return code describes a positive intermediate response.
 */
export function positiveIntermediate(code: number): boolean {
  return code >= 300 && code < 400
}

function isNotBlank(str: string): boolean {
  return str.trim() !== ""
}